﻿<h1>Line Break Rules in Go</h1>

<p>
If you have written go code much, you should have known that
we can't use arbitrary code styles in Go programming.
Specifically speaking,
we can't break a code line at an arbitrary space character position.
The remaining of this article will list the detailed line break rules in Go.
</p>

<h3>Semicolon Insertion Rules</h3>

<div>

One rule we often obey in practice is, we should not put
the a starting curly brace (<code>{</code>) of any explicit code block on a new line.
For example, the following <code>for</code> loop code block fails to compile.

<pre class="line-numbers"><code class="language-go">	for i := 5; i > 0; i--
	{ // unexpected newline, expecting { after for clause
	}
</code></pre>

To make it compiles okay, the starting curly brace mustn't be put on a new line,
like the following:

<pre class="line-numbers"><code class="language-go">	for i := 5; i > 0; i-- {
	}
</code></pre>

<p>
</p>

However, there are some exceptions for the rule mentioned above.
For example, the following bare <code>for</code> loop block compiles okay.

<pre class="line-numbers"><code class="language-go">	for
	{
		// do something ...
	}
</code></pre>

<p>
</p>

<p>
Then, what are the fundamental rules to do line breaks in Go programming?
Before answering this question, we should know a fact that the formal Go grammar
uses semicolons <code>;</code> as terminators of code lines.
However, we seldom use semicolons in our Go code. Why?
The reason is most semicolons are optional and can be omitted.
Go compilers will insert the omitted semicolons
for us automatically in compiling.
</p>

For example, the ten semicolons in the following program are all optional.

<pre class="line-numbers"><code class="language-go">package main;

import "fmt";

func main() {
	var (
		i   int;
		sum int;
	);
	for i < 6 {
		sum += i;
		i++;
	};
	fmt.Println(sum);
};
</code></pre>

<p>
Assume the above program is stored in a file named <code>semicolons.go</code>,
we can run <code>go fmt semicolons.go</code> to remove all the unnecessary
semicolons from that file.
Compilers will insert the removed semicolons back (in memory) automatically
in compiling the source code.
</p>

<p>
What are the semicolons insertion rules in Go?
Let's read <a href="https://golang.org/ref/spec#Semicolons">the semicolon rules listed in Go specification</a>.
</p>

<div class="alert alert-success">
<p>
The formal grammar uses semicolons ";" as terminators in a number of productions.
Go programs may omit most of these semicolons using the following two rules:
</p>

<ol>
<li>
	When the input is broken into tokens, a semicolon is automatically
	inserted into the token stream immediately after a line's final token
	if that token is
	<ul>
	<li>
		an <a href="keywords-and-identifiers.html#identifier">identifier</a>
	</li>
	<li>
		an integer, floating-point, imaginary, rune, or string <a href="basic-types-and-value-literals.html#basic-value-literals">literal</a>
	</li>
	<li>
		one of the keywords <code>break</code>, <code>continue</code>,
		<code>fallthrough</code>, or <code>return</code>
	</li>
	<li>
		one of the operators and punctuation <code>++</code>,
		<code>--</code>, <code>)</code>,
		<code>]</code>, or <code>}</code>
	</li>
	</ul>
</li>
<li>
	To allow complex statements to occupy a single line,
	a semicolon may be omitted before a closing <code>)</code> or <code>}</code>.
</li>
</ol>
</div>

<p>
For the scenarios listed in the first rule, surely, we can also insert
the semicolons manually, just like the semicolons in the last code example.
In other words, these semicolons are optional in programming.
</p>

<p>
The second rule means the last semicolon in a multi-item declaration before
the closing sign <code>)</code> and the last semicolon within a code block or
a (struct or interface) type declaration before the closing sign
<code>}</code> are optional.
If the last semicolon is absent, compilers will automatically insert it back.
</p>

The second rule lets us be able to write the following valid code.

<pre class="line-numbers"><code class="language-go">import (_ "math"; "fmt")
var (a int; b string)
const (M = iota; N)
type (MyInt int; T struct{x bool; y int32})
type I interface{m1(int) int; m2() string}
func f() {print("a"); panic(nil)}
</code></pre>

Compilers will automatically insert the omitted senicolons for us,
as the following code shows.

<pre class="line-numbers"><code class="language-go">var (a int; b string;);
const (M = iota; N;);
type (MyInt int; T struct{x bool; y int32;};);
type I interface{m1(int) int; m2() string;};
func f() {print("a"); panic(nil);};
</code></pre>

<p>
</p>

Compilers will not insert semicolons for any other scenarios.
We must insert the semicolons manually as needed for other scenarios.
For example,
the first semicolon at each line in the last code example are all required.
The semicolons in the following example are also required.

<pre class="line-numbers"><code class="language-go">var a = 1; var b = true
a++; b = !b
print(a); print(b)
</code></pre>

<p>
</p>

<p>
From the two rules, we know that a semicolon will never be inserted
just after the <code>for</code> keyword.
This is why the bare <code>for</code> loop example shown above is valid.
</p>

One consequence of the semicolon insertion rules is that the self increment
and self decrement operations must appear as statements.
They can't be used as expressions.
For example, the following code is invalid.

<pre class="line-numbers"><code class="language-go">func f() {
	a := 0
	// The following two lines both fail to compile.
	println(a++) // unexpected ++, expecting comma or )
	println(a--) // unexpected --, expecting comma or )
}
</code></pre>

The reason why the above code is invalid is compilers will view it as

<pre class="line-numbers"><code class="language-go">func f() {
	a := 0;
	println(a++;);
	println(a--;);
}
</code></pre>

<p>
</p>

Another consequence of the semicolon insertion rules is
we can't break a line before the dot <code>.</code> in a selector.
We can only break a line after the dot, as the following code shows

<pre class="line-numbers"><code class="language-go">	anObject.
		MethodA().
		MethodB().
		MethodC()
</code></pre>

whereas the following code fails to compile.

<pre class="line-numbers"><code class="language-go">	anObject
		.MethodA()
		.MethodB()
		.MethodC()
</code></pre>

Compilers will insert a semicolon at the end of each line
in the modified version, so the above code is equivalent to
the following code which is obviously invalid.

<pre class="line-numbers"><code class="language-go">	anObject;
		.MethodA();
		.MethodB();
		.MethodC();
</code></pre>

<p>
</p>

<!--
<p>
There are many other inappropriate line break cases.
If you think the above line break rules
are some complex to grasp, here is simpler rule to follow.
The simpler rule is a subset of the full rules.
</p>

<div class="alert alert-success">
Generally, we should only break a code line just after a binary operator,
an assignment sign, a single dot (<code>.</code>), a comma, a semicolon,
or an opening brace (<code>{</code>, <code>[</code>, <code>(</code>).
</div>
<p>
</p>
-->

The semicolon insertion rules make us write cleaner code.
They also make it is possible to write some valid but a little weird code.
For example,

<pre class="line-numbers must-line-numbers"><code class="language-go">package main

import "fmt"

func alwaysFalse() bool {return false}

func main() {
	for
	i := 0
	i < 6
	i++ {
		// use i ...
	}

	if x := alwaysFalse()
	!x {
		// do something ...
	}

	switch alwaysFalse()
	{
	case true: fmt.Println("true")
	case false: fmt.Println("false")
	}
}
</code></pre>

<p>
All the three control flow blocks are valid.
Compilers will insert a semicolon at the end of each of line <i>9</i>,
<i>10</i>, <i>15</i> and <i>20</i>.
</p>

Please note, the <code>switch-case</code> block in the above example
will print a <code>true</code> instead of a <code>false</code>.
It is different from

<pre class="line-numbers"><code class="language-go">	switch alwaysFalse() {
	case true: fmt.Println("true")
	case false: fmt.Println("false")
	}
</code></pre>

If we use the <code>go fmt</code> commend to format the former one,
a semicolon will be appended automatically after the
<code>alwaysFalse()</code> call, so it will become to

<pre class="line-numbers"><code class="language-go">	switch alwaysFalse();
	{
	case true: fmt.Println("true")
	case false: fmt.Println("false")
	}
</code></pre>

The modified version is equivalent to the following one.

<pre class="line-numbers"><code class="language-go">	switch alwaysFalse(); true {
	case true: fmt.Println("true")
	case false: fmt.Println("false")
	}
</code></pre>

<p>
That is why it will print a <code>true</code>.
</p>

<p>
It is a good habit to run <code>go fmt</code>
and <code>go vet</code> often for your code.
</p>

For a rare case. the semicolon insertion rules also make some code look valid
but invalid actually.
For example, the following code snippet fails to compile.

<pre class="line-numbers"><code class="language-go">func f(x int) {
	switch x {
	case 1:
	{
		goto A
		A: // compiles okay
	}
	case 2:
		goto B
		B: // syntax error: missing statement after label
	case 0:
		goto C
		C: // compiles okay
	}
}
</code></pre>

<p>
</p>

The compilation error message indicates that there must be
a statement following a label declaration.
But it looks none label in the above two examples is followed by a statement.
Why is only the <code>B:</code> label declaration invalid?
The reason is, by the second semicolon insertion rule mentioned above,
compilers will insert a semicolon before each of the <code>}</code> characters
following the <code>A:</code> and <code>C:</code> label declarations.
As the following code shows.

<pre class="line-numbers"><code class="language-go">func f(x int) {
	switch x {
	case 1:
	{
		goto A
		A:
	;} // a semicolon is inserted here
	case 2:
		goto B
		B: // syntax error: missing statement after label
	case 0:
		goto C
		C:
	;} // a semicolon is inserted here
}
</code></pre>

<p>
A solo semicolon represents a <a href="expressions-and-statements.html#simple-statements">blank statement</a> actually,
which is why the <code>A:</code> and <code>C:</code> label declarations are both valid.
On the other hand, the <code>B:</code> label declaration is followed by <code>case 0:</code>,
which is not a statement, so the <code>B:</code> label declaration is invalid.
</p>

<p>
We can manually insert a semicolon (a blank statement) at the end of
each of the <code>B:</code> label declaration to make it compile okay.
</p>

</div>

<a class="anchor" id="commas"></a>
<h3>Comma (<code>,</code>) Will Not Be Inserted Automatically</h3>

<div>
<p>
In some syntax forms containing multiple alike items,
commas are used as separators,
such as composite literals, function argument lists,
function parameter lists and function result lists.
In such a syntax form, the last item can always be followed by a comma.
If the following comma is the last effective character in its respective code line,
then the comma is required, otherwise, it is optional.
Compilers will not insert commas automatically for any cases.
</p>

For example, the following code snippet is valid.

<pre class="line-numbers must-line-numbers"><code class="language-go">func f1(a int, b string,) (x bool, y int,) {
	return true, 789
}
var f2 func (a int, b string) (x bool, y int)
var f3 func (a int, b string, // the last comma is required
) (x bool, y int,             // the last comma is required
)
var _ = []int{2, 3, 5, 7, 9,} // the last comma is optional
var _ = []int{2, 3, 5, 7, 9,  // the last comma is required
}
var _ = []int{2, 3, 5, 7, 9}
var _, _ = f1(123, "Go",) // the last comma is optional
var _, _ = f1(123, "Go",  // the last comma is required
)
var _, _ = f1(123, "Go")
</code></pre>

However, the following code snippet is invalid,
for compilers will insert a semicolon for each line in the code,
except the second line.
There are three lines which will cause <code>unexpected newline</code> syntax errors.

<pre class="line-numbers must-line-numbers"><code class="language-go">func f1(a int, b string,) (x bool, y int // error
) {
	return true, 789
}
var _ = []int{2, 3, 5, 7 // error: unexpected newline
}
var _, _ = f1(123, "Go" // error: unexpected newline
)
</code></pre>

<p>
</p>

</div>

<h3>Final Words</h3>

<p>
Like some other design details in Go,
there are both praises and criticisms for the semicolon insertion rules.
Some programmers don't like the rules,
for they think the rules limit the freedom of code styles.
Praisers think the rules make code compile faster, and make the code written
by different programmers look similar, so that it is easy to understand
the code written by each other.
</p>





